const User = require('../models/User');
const Joi = require('joi');

// 用户查询验证Schema
const querySchema = Joi.object({
  page: Joi.number().integer().min(1).default(1),
  limit: Joi.number().integer().min(1).max(100).default(10),
  search: Joi.string().allow('').default(''),
  role: Joi.string().valid('admin', 'user').allow('').default(''),
  status: Joi.string().valid('online', 'offline').allow('').default('')
});

// 用户更新验证Schema
const updateSchema = Joi.object({
  name: Joi.string().max(50),
  email: Joi.string().email(),
  skills: Joi.array().items(Joi.string()),
  role: Joi.string().valid('admin', 'user')
});

// 获取用户列表（仅管理员）
exports.getUsers = async (req, res) => {
  try {
    // 验证查询参数
    const { error, value } = querySchema.validate(req.query);
    if (error) {
      return res.status(400).json({
        success: false,
        message: '查询参数验证失败',
        error: error.details[0].message
      });
    }

    const { page, limit, search, role, status } = value;
    const skip = (page - 1) * limit;

    // 构建查询条件
    const query = {};
    
    // 搜索条件
    if (search) {
      query.$or = [
        { username: { $regex: search, $options: 'i' } },
        { name: { $regex: search, $options: 'i' } },
        { email: { $regex: search, $options: 'i' } }
      ];
    }
    
    // 角色筛选
    if (role) {
      query.role = role;
    }
    
    // 状态筛选
    if (status) {
      query.status = status;
    }

    // 检查数据库连接状态
    if (mongoose.connection.readyState !== 1) {
      console.warn('数据库未连接，返回模拟数据');
      // 返回模拟数据，避免前端完全无法工作
      return res.status(200).json({
        success: true,
        data: {
          users: [],
          pagination: {
            currentPage: page,
            totalPages: 0,
            totalUsers: 0,
            hasNext: false,
            hasPrev: false
          }
        }
      });
    }

    // 执行查询
    const users = await User.find(query)
      .skip(skip)
      .limit(limit)
      .sort({ createdAt: -1 });

    // 获取总数
    const total = await User.countDocuments(query);

    res.status(200).json({
      success: true,
      data: {
        users: users.map(user => user.toJSON()),
        pagination: {
          currentPage: page,
          totalPages: Math.ceil(total / limit),
          totalUsers: total,
          hasNext: page < Math.ceil(total / limit),
          hasPrev: page > 1
        }
      }
    });
  } catch (error) {
    console.error('获取用户列表错误:', error);
    // 判断是否为数据库连接错误
    if (error.message.includes('ECONNREFUSED') || error.message.includes('connect')) {
      // 返回模拟数据，允许前端继续运行
      const { page = 1, limit = 10 } = req.query;
      return res.status(200).json({
        success: true,
        data: {
          users: [],
          pagination: {
            currentPage: parseInt(page),
            totalPages: 0,
            totalUsers: 0,
            hasNext: false,
            hasPrev: false
          }
        }
      });
    }
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};

// 获取用户详情
exports.getUserById = async (req, res) => {
  try {
    const { id } = req.params;

    // 验证ID格式
    if (!id.match(/^[0-9a-fA-F]{24}$/)) {
      return res.status(400).json({
        success: false,
        message: '无效的用户ID'
      });
    }

    const user = await User.findById(id);
    
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    res.status(200).json({
      success: true,
      data: {
        user: user.toJSON()
      }
    });
  } catch (error) {
    console.error('获取用户详情错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};

// 更新用户信息
exports.updateUser = async (req, res) => {
  try {
    const { id } = req.params;
    const updateData = req.body;

    // 验证ID格式
    if (!id.match(/^[0-9a-fA-F]{24}$/)) {
      return res.status(400).json({
        success: false,
        message: '无效的用户ID'
      });
    }

    // 验证更新数据
    const { error, value } = updateSchema.validate(updateData);
    if (error) {
      return res.status(400).json({
        success: false,
        message: '更新数据验证失败',
        error: error.details[0].message
      });
    }

    // 检查用户是否存在
    const user = await User.findById(id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    // 检查权限：管理员可以更新任何用户，普通用户只能更新自己
    if (req.user.role !== 'admin' && req.user.userId !== id) {
      return res.status(403).json({
        success: false,
        message: '没有权限更新此用户'
      });
    }

    // 如果不是管理员，不能修改角色
    if (req.user.role !== 'admin' && value.role) {
      delete value.role;
    }

    // 更新用户信息
    const updatedUser = await User.findByIdAndUpdate(
      id,
      { $set: value },
      { new: true, runValidators: true }
    );

    res.status(200).json({
      success: true,
      message: '用户信息更新成功',
      data: {
        user: updatedUser.toJSON()
      }
    });
  } catch (error) {
    console.error('更新用户信息错误:', error);
    
    if (error.name === 'ValidationError') {
      return res.status(400).json({
        success: false,
        message: '数据验证失败',
        error: Object.values(error.errors).map(err => err.message)
      });
    }
    
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};

// 删除用户（仅管理员）
exports.deleteUser = async (req, res) => {
  try {
    const { id } = req.params;

    // 验证ID格式
    if (!id.match(/^[0-9a-fA-F]{24}$/)) {
      return res.status(400).json({
        success: false,
        message: '无效的用户ID'
      });
    }

    // 检查用户是否存在
    const user = await User.findById(id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    // 不能删除自己
    if (req.user.userId === id) {
      return res.status(400).json({
        success: false,
        message: '不能删除自己的账户'
      });
    }

    // 删除用户
    await User.findByIdAndDelete(id);

    res.status(200).json({
      success: true,
      message: '用户删除成功'
    });
  } catch (error) {
    console.error('删除用户错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};